package com.smart.translator.ble;

import android.Manifest;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothGatt;
import android.bluetooth.BluetoothGattCallback;
import android.bluetooth.BluetoothGattCharacteristic;
import android.bluetooth.BluetoothGattDescriptor;
import android.bluetooth.BluetoothGattService;
import android.bluetooth.BluetoothManager;
import android.bluetooth.BluetoothProfile;
import android.bluetooth.le.BluetoothLeScanner;
import android.bluetooth.le.ScanCallback;
import android.bluetooth.le.ScanFilter;
import android.bluetooth.le.ScanResult;
import android.bluetooth.le.ScanSettings;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.content.pm.PackageManager;
import android.os.Build;
import android.os.Handler;
import android.os.Looper;
import androidx.core.app.ActivityCompat;
import com.smart.translator.service.BleForegroundService;
import com.smart.translator.ota.OtaManager;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

// 导入DeviceFragment相关的数据处理类
import com.smart.translator.util.AdpcmDecoder;
import com.smart.translator.util.AudioResampler;
import com.smart.translator.util.AsrWsClient;
import com.smart.translator.util.DoubaoTTSManager;
import java.io.ByteArrayOutputStream;
import java.util.Arrays;
import android.util.Base64;
import org.json.JSONObject;
import org.json.JSONException;
import java.nio.charset.StandardCharsets;
import java.util.HashSet;
import java.util.Set;

public class BleManager {
    private static final String TAG = "BleManager";
    private static final String PREFS_NAME = "ble_manager_prefs";
    private static final String KEY_AUTO_RECONNECT = "auto_reconnect";
    private static final String KEY_LAST_DEVICE_ADDRESS = "last_device_address";
    
    // BLE UUIDs (使用AudioProcessor中的常量)
    private static final UUID FFF1_UUID = AudioProcessor.FFF1_UUID;
    private static final UUID FFF4_UUID = AudioProcessor.FFF4_UUID;
    private static final UUID FFF3_UUID = AudioProcessor.FFF3_UUID;

    private static final UUID FFF6_UUID = AudioProcessor.FFF6_UUID;
    
    private static final UUID F2_UUID = AudioProcessor.F2_UUID;
    
    // OTA相关的UUID (来自OTASampleCode1.2.5的真实UUID定义)
    private static final UUID OTA_SERVICE_UUID = UUID.fromString("02f00000-0000-0000-0000-00000000fe00");
    private static final UUID OTA_SEND_CHARACTERISTIC_UUID = UUID.fromString("02f00000-0000-0000-0000-00000000ff01");
    private static final UUID OTA_RECV_CHARACTERISTIC_UUID = UUID.fromString("02f00000-0000-0000-0000-00000000ff02");
    
    // DSP OTA服务UUID（与设备一致）
    private static final UUID OTA_SERVICE_UUID_DSP = UUID.fromString("02f00000-0000-0000-0000-00000000fd00");
    private static final UUID OTA_CHAR_UUID_VERSION_INFO_DSP = UUID.fromString("02f00000-0000-0000-0000-00000000fe00");
    private static final UUID OTA_CHAR_UUID_TX_DSP = UUID.fromString("02f00000-0000-0000-0000-00000000fe01");
    private static final UUID OTA_CHAR_UUID_RX_DSP = UUID.fromString("02f00000-0000-0000-0000-00000000fe02");
    private static final UUID OTA_CHAR_UUID_NOTI_DSP = UUID.fromString("02f00000-0000-0000-0000-00000000fe03");
    
    // 外部Flash OTA服务UUID（与设备一致）
    private static final UUID OTA_SERVICE_UUID_EXTERNAL_FLASH = UUID.fromString("02f00000-0000-0000-0000-00000000fc00");
    private static final UUID OTA_CHAR_UUID_VERSION_INFO_EXTERNAL_FLASH = UUID.fromString("02f00000-0000-0000-0000-00000000fd03");
    private static final UUID OTA_CHAR_UUID_TX_EXTERNAL_FLASH = UUID.fromString("02f00000-0000-0000-0000-00000000fd00");
    private static final UUID OTA_CHAR_UUID_RX_EXTERNAL_FLASH = UUID.fromString("02f00000-0000-0000-0000-00000000fd01");
    private static final UUID OTA_CHAR_UUID_NOTI_EXTERNAL_FLASH = UUID.fromString("02f00000-0000-0000-0000-00000000fd02");
    
    // 扫描和重连配置
    private static final long SCAN_PERIOD = 10000; // 10秒
    private static final long RECONNECT_DELAY = 2000; // 2秒
    private static final long CONNECTION_TIMEOUT = 10000; // 10秒
    private static final int MAX_RECONNECT_ATTEMPTS = 5;
    
    // 单例实例
    private static volatile BleManager instance;
    
    // BLE相关对象
    private BluetoothAdapter bluetoothAdapter;
    private BluetoothLeScanner bluetoothLeScanner;
    private BluetoothGatt bluetoothGatt;
    private BluetoothDevice connectedDevice;
    
    // 状态管理
    private boolean isInitialized = false;
    private boolean isScanning = false;
    private boolean isConnecting = false;
    private boolean isConnected = false;
    private boolean isUserDisconnected = false; // 用户主动断开标记
    private int reconnectAttempts = 0;
    
    // 特征管理
    private BluetoothGattCharacteristic notifyCharacteristic;
    private BluetoothGattCharacteristic writeCharacteristic;
    private BluetoothGattCharacteristic fff3WriteCharacteristic;
    
    // 跟踪已启用通知的特征，防止重复启用
    private java.util.Set<UUID> enabledNotifications = new java.util.HashSet<>();
    
    // 新增：串行enable notify队列
    private java.util.Queue<BluetoothGattCharacteristic> pendingNotifyQueue = new java.util.LinkedList<>();
    private boolean isEnablingNotify = false;
    
    // 新增：记录每个特征的重试次数
    private java.util.Map<UUID, Integer> notifyRetryCountMap = new java.util.HashMap<>();
    private static final int MAX_NOTIFY_RETRY = 3;
    private static final int NOTIFY_RETRY_DELAY_MS = 100;
    
    // 回调接口
    private BleConnectionListener connectionListener;
    private BleDataListener dataListener;
    
    // 系统对象
    private Context context;
    private Handler mainHandler;
    private SharedPreferences prefs;
    
    // 重连定时器
    private Runnable reconnectRunnable;
    private Runnable connectionTimeoutRunnable;
    
    // 音频处理器
    private AudioProcessor audioProcessor;
    
    // 新增：电池电量相关
    private int batteryLevel = -1; // -1表示未获取到
    private long lastBatteryUpdateTime = 0;
    private static final long BATTERY_UPDATE_INTERVAL = 30000; // 30秒更新一次电池电量
    private Handler batteryUpdateHandler = new Handler(Looper.getMainLooper());
    private Runnable batteryUpdateRunnable;
    
    // 扫描回调
    private final ScanCallback scanCallback = new ScanCallback() {
        @Override
        public void onScanResult(int callbackType, ScanResult result) {
            android.util.Log.d(TAG, "扫描发现设备: " + result.getDevice().getAddress());
            
            if (ActivityCompat.checkSelfPermission(context, Manifest.permission.BLUETOOTH_CONNECT) != PackageManager.PERMISSION_GRANTED) {
                return;
            }
            
            BluetoothDevice device = result.getDevice();
            // ⭐ 修复：移除自动连接逻辑，扫描到的设备应该由UI层处理
            // 扫描到的设备会在DeviceFragment的扫描回调中显示给用户选择
            android.util.Log.d(TAG, "扫描到设备: " + device.getAddress() + " - " + device.getName());
            
            // ⭐ 新增：通知扫描结果监听器
            if (scanResultListener != null) {
                int rssi = result.getRssi();
                scanResultListener.onScanResult(device, rssi);
            }
        }
        
        @Override
        public void onScanFailed(int errorCode) {
            android.util.Log.e(TAG, "扫描失败，错误码: " + errorCode);
            isScanning = false;
            
            // ⭐ 新增：通知扫描失败监听器
            if (scanResultListener != null) {
                scanResultListener.onScanFailed(errorCode);
            }
            
            // 扫描失败后延迟重试
            mainHandler.postDelayed(() -> {
                if (isInitialized && !isConnected && !isUserDisconnected) {
                    startScan();
                }
            }, 5000);
        }
    };
    
    // GATT回调
    private final BluetoothGattCallback gattCallback = new BluetoothGattCallback() {
        @Override
        public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
            android.util.Log.d(TAG, "连接状态变化: status=" + status + ", newState=" + newState + 
                ", 设备: " + gatt.getDevice().getAddress());
            
            // 取消连接超时
            if (connectionTimeoutRunnable != null) {
                mainHandler.removeCallbacks(connectionTimeoutRunnable);
                connectionTimeoutRunnable = null;
            }
            
            if (newState == BluetoothProfile.STATE_CONNECTED) {
                android.util.Log.i(TAG, "✅ 设备连接成功: " + gatt.getDevice().getAddress());
                android.util.Log.d(TAG, "Android版本: " + Build.VERSION.SDK_INT + " (API " + Build.VERSION.SDK_INT + ")");
                
                isConnecting = false;
                isConnected = true;
                reconnectAttempts = 0; // 重置重连计数
                
                // ⭐ 修复：连接成功时保存历史设备地址
                saveLastDeviceAddress(gatt.getDevice().getAddress());
                
                // 设置高优先级连接，优化OTA传输
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                    gatt.requestConnectionPriority(BluetoothGatt.CONNECTION_PRIORITY_HIGH);
                    android.util.Log.d(TAG, "已设置高优先级连接");
                }
                
                // 通知连接成功
                if (connectionListener != null) {
                    connectionListener.onConnected(gatt.getDevice());
                }
                
                updateServiceNotification("设备已连接");
                
                // ⭐ 修复：移除连接建立后立即启动电池电量自动更新的代码
                // 电池电量读取现在会在OTA版本读取完成后进行
                // mainHandler.postDelayed(() -> {
                //     if (isConnected && bluetoothGatt != null) {
                //         startBatteryAutoUpdate();
                //     }
                // }, 3000); // 延迟3秒启动电池电量更新
                
                // 发现服务
                if (ActivityCompat.checkSelfPermission(context, Manifest.permission.BLUETOOTH_CONNECT) == PackageManager.PERMISSION_GRANTED) {
                    android.util.Log.d(TAG, "开始发现服务...");
                    boolean discover = gatt.discoverServices();
                    android.util.Log.d(TAG, "服务发现请求结果: " + discover);
                    
                    // ⭐ 修复：添加服务发现失败的处理
                    if (!discover) {
                        android.util.Log.e(TAG, "服务发现请求失败，尝试延迟重试");
                        mainHandler.postDelayed(() -> {
                            if (isConnected && bluetoothGatt != null) {
                                android.util.Log.d(TAG, "延迟重试服务发现...");
                                boolean retryDiscover = bluetoothGatt.discoverServices();
                                android.util.Log.d(TAG, "延迟重试服务发现结果: " + retryDiscover);
                            }
                        }, 1000); // 延迟1秒重试
                    }
                } else {
                    android.util.Log.e(TAG, "缺少BLUETOOTH_CONNECT权限，无法发现服务");
                }
                
            } else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
                android.util.Log.w(TAG, "❌ 设备已断开: " + gatt.getDevice().getAddress() + ", status: " + status);
                isConnecting = false;
                isConnected = false;
                
                // 清理已启用通知的列表
                enabledNotifications.clear();
                android.util.Log.d(TAG, "设备断开，已清理已启用通知列表");
                
                // 通知连接断开
                if (connectionListener != null) {
                    connectionListener.onDisconnected(gatt.getDevice());
                }
                
                // 停止电池电量自动更新
                stopBatteryAutoUpdate();
                
                // 清理资源
                if (bluetoothGatt != null) {
                    bluetoothGatt.close();
                    bluetoothGatt = null;
                }
                
                // 如果不是用户主动断开，安排重连
                if (!isUserDisconnected) {
                    android.util.Log.d(TAG, "安排自动重连...");
                    scheduleReconnect();
                } else {
                    android.util.Log.d(TAG, "用户主动断开，不进行重连");
                    updateServiceNotification("设备已断开");
                    connectedDevice = null;
                }
            } else if (newState == BluetoothProfile.STATE_CONNECTING) {
                android.util.Log.d(TAG, "🔄 正在连接设备: " + gatt.getDevice().getAddress());
            } else if (newState == BluetoothProfile.STATE_DISCONNECTING) {
                android.util.Log.d(TAG, "🔄 正在断开设备: " + gatt.getDevice().getAddress());
            }
        }
        
        @Override
        public void onServicesDiscovered(BluetoothGatt gatt, int status) {
            android.util.Log.d(TAG, "=== onServicesDiscovered 被调用 ===");
            android.util.Log.d(TAG, "服务发现完成: status=" + status + ", 设备: " + gatt.getDevice().getAddress());
            
            if (status == BluetoothGatt.GATT_SUCCESS) {
                android.util.Log.i(TAG, "✅ 服务发现成功，开始设置特征");
                
                // 打印所有发现的服务
                List<BluetoothGattService> services = gatt.getServices();
                android.util.Log.d(TAG, "发现的服务数量: " + services.size());
                for (BluetoothGattService service : services) {
                    android.util.Log.d(TAG, "服务: " + service.getUuid());
                }
                
                setupCharacteristics(gatt);
                
                // 初始化OtaManager
                OtaManager otaManager = OtaManager.getInstance();
                if (!otaManager.isInitialized()) {
                    android.util.Log.d(TAG, "初始化OtaManager");
                    otaManager.init(context, BleManager.this);
                }
                
                // 服务发现完成后通知OtaManager重新初始化特征
                android.util.Log.d(TAG, "通知OtaManager重新初始化特征");
                otaManager.onConnectionEstablished();
                
                // 服务发现成功后主动获取连接参数
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                    android.util.Log.d(TAG, "服务发现完成，主动获取连接参数");
                    // 使用默认连接参数通知OtaManager
                    // 典型的BLE连接参数：间隔6（7.5ms），延迟0，超时500ms
                    double defaultIntervalMs = 7.5; // 6 * 1.25ms
                    int defaultLatency = 0;
                    int defaultTimeout = 500;
                    otaManager.updateConnectionParameters(defaultIntervalMs, defaultLatency, defaultTimeout);
                    android.util.Log.d(TAG, "已设置默认连接参数 - 间隔: " + defaultIntervalMs + "ms, 延迟: " + defaultLatency + ", 超时: " + defaultTimeout + "ms");
                }
                
                // 服务发现成功后自动请求MTU
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
                    gatt.requestMtu(247);
                }
                
                // 版本获取移到MTU协商完成后进行
                
            } else {
                android.util.Log.e(TAG, "❌ 服务发现失败: " + status);
                // 服务发现失败，可能需要重连
                if (!isUserDisconnected) {
                    android.util.Log.d(TAG, "服务发现失败，安排重连");
                    scheduleReconnect();
                }
            }
            android.util.Log.d(TAG, "=== onServicesDiscovered 结束 ===");
        }
        
        @Override
        public void onCharacteristicChanged(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
            UUID characteristicUuid = characteristic.getUuid();
            byte[] data = characteristic.getValue();
            
            //android.util.Log.d(TAG, "特征数据变化: " + characteristicUuid + ", 数据: " + bytesToHex(data));
            
            // 处理OTA响应数据
            if (OTA_SERVICE_UUID.equals(characteristicUuid) || OTA_SEND_CHARACTERISTIC_UUID.equals(characteristicUuid) || OTA_RECV_CHARACTERISTIC_UUID.equals(characteristicUuid)) {
                android.util.Log.d(TAG, "处理CM3 OTA响应数据");
                OtaManager otaManager = OtaManager.getInstance();
                otaManager.handleOtaResponse(data);
                return;
            }
            
            // 处理DSP OTA响应数据
            if (OTA_SERVICE_UUID_DSP.equals(characteristicUuid) || OTA_CHAR_UUID_TX_DSP.equals(characteristicUuid) || 
                OTA_CHAR_UUID_RX_DSP.equals(characteristicUuid) || OTA_CHAR_UUID_NOTI_DSP.equals(characteristicUuid) ||
                OTA_CHAR_UUID_VERSION_INFO_DSP.equals(characteristicUuid)) {
                android.util.Log.d(TAG, "处理DSP OTA响应数据，特征: " + characteristicUuid);
                OtaManager otaManager = OtaManager.getInstance();
                otaManager.handleDspOtaResponse(data);
                return;
            }
            
            // 处理外部Flash OTA响应数据
            if (OTA_SERVICE_UUID_EXTERNAL_FLASH.equals(characteristicUuid) || OTA_CHAR_UUID_TX_EXTERNAL_FLASH.equals(characteristicUuid) || 
                OTA_CHAR_UUID_RX_EXTERNAL_FLASH.equals(characteristicUuid) || OTA_CHAR_UUID_NOTI_EXTERNAL_FLASH.equals(characteristicUuid) ||
                OTA_CHAR_UUID_VERSION_INFO_EXTERNAL_FLASH.equals(characteristicUuid)) {
                android.util.Log.d(TAG, "处理外部Flash OTA响应数据，特征: " + characteristicUuid);
                OtaManager otaManager = OtaManager.getInstance();
                otaManager.handleExternalFlashOtaResponse(data);
                return;
            }
            
            // 处理音频数据
            if (FFF1_UUID.equals(characteristicUuid)) {
                android.util.Log.d(TAG, "收到音频数据: " + data.length + " 字节");
                
                // 通知数据监听器
                if (dataListener != null) {
                    dataListener.onAudioDataReceived(data, false);
                }
                
                // 处理音频数据
                if (audioProcessor != null) {
                    audioProcessor.handleBluetoothData(data);
                }
                return;
            }
            
            // 处理FFF4音频数据
            if (FFF4_UUID.equals(characteristicUuid)) {
                //android.util.Log.d(TAG, "收到FFF4音频数据: " + data.length + " 字节");
                
                // 处理FFF4音频数据
                if (audioProcessor != null) {
                    // 与DeviceFragment一致，FFF4数据也通过handleBluetoothData处理（包含ASR流式发送）
                    audioProcessor.handleBluetoothData(data);
                } else {
                    android.util.Log.w(TAG, "AudioProcessor为空，无法处理FFF4数据");
                }
                return;
            }

              // 处理FFF6按键数据
              if (FFF6_UUID.equals(characteristicUuid)) {
                  android.util.Log.d(TAG, "收到FFF6按键数据: " + data.length + " 字节, 内容: " + bytesToHex(data));
                
                // 处理FFF4音频数据
                if (audioProcessor != null) {
                    audioProcessor.handleFFF6KeyData(data);
                } else {
                    android.util.Log.w(TAG, "AudioProcessor为空，无法处理FFF6按键数据");
                }
                return;
            }

            
            
            // 通知数据监听器
            if (dataListener != null) {
                dataListener.onDataReceived(characteristicUuid, data);
            }
        }
        
        @Override
        public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
            //android.util.Log.d(TAG, "特征写入完成: " + characteristic.getUuid() + ", status=" + status);
            
            // 设置OtaManager的writeStatus标志，确保擦除逻辑能正常工作
            if (status == BluetoothGatt.GATT_SUCCESS) {
                OtaManager.getInstance().setWriteStatus(true);
            }
        }
        
        @Override
        public void onDescriptorWrite(BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
            UUID charUuid = descriptor.getCharacteristic().getUuid();
            notifyRetryCountMap.remove(charUuid);
            android.util.Log.d(TAG, "描述符写入完成: " + descriptor.getUuid() + ", status=" + status);
            isEnablingNotify = false;
            
            // 继续处理下一个Notify特征
            enableNextNotify(gatt);
        }

        @Override
        public void onMtuChanged(BluetoothGatt gatt, int mtu, int status) {
            if (status == BluetoothGatt.GATT_SUCCESS) {
                android.util.Log.d(TAG, "MTU协商成功: " + mtu);
                // 通知OtaManager
                OtaManager.getInstance().setMtuSize(mtu);
                
                // MTU协商完成后请求优化连接参数
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                    android.util.Log.d(TAG, "请求优化连接参数");
                    // 请求更快的连接间隔（7.5ms = 6 * 1.25ms）
                    gatt.requestConnectionPriority(BluetoothGatt.CONNECTION_PRIORITY_HIGH);
                    
                    // 延迟请求连接参数更新
                    mainHandler.postDelayed(() -> {
                        try {
                            // 使用反射调用requestConnectionParameters方法（Android 8.0+）
                            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                                android.util.Log.d(TAG, "主动请求连接参数更新");
                                // 设置连接参数：间隔6（7.5ms），延迟0，超时500ms
                                gatt.requestConnectionPriority(BluetoothGatt.CONNECTION_PRIORITY_HIGH);
                                android.util.Log.d(TAG, "连接参数更新请求已发送，等待设备响应...");
                            }
                        } catch (Exception e) {
                            android.util.Log.w(TAG, "请求连接参数更新失败", e);
                        }
                    }, 1000); // 延迟1秒请求
                } else {
                    android.util.Log.w(TAG, "当前Android版本不支持连接参数更新: " + Build.VERSION.SDK_INT);
                }
                
                // MTU协商完成，延迟获取设备版本信息
                mainHandler.postDelayed(() -> {
                    // ⭐ 修复：检查OTA状态，确保在OTA更新期间不会触发版本获取
                    OtaManager otaManager = OtaManager.getInstance();
                    if (otaManager.isUpdating() || otaManager.getCurrentState() == OtaManager.OTA_STATE_UPDATING) {
                        android.util.Log.d(TAG, "OTA更新正在进行中，跳过版本获取");
                        return;
                    }
                    
                    // ⭐ 修复：将版本请求移到后台线程，避免主线程阻塞
                    new Thread(() -> {
                        try {
                            android.util.Log.d(TAG, "开始获取设备版本信息");
                            otaManager.requestDeviceVersion();
                        } catch (Exception e) {
                            android.util.Log.e(TAG, "获取设备版本信息失败", e);
                        }
                    }).start();
                }, 1000); // 延迟1秒确保所有状态都已同步
            } else {
                android.util.Log.d(TAG, "MTU协商失败，使用默认: 23");
                OtaManager.getInstance().setMtuSize(23);
            }
        }
        
        public void onConnectionParametersUpdated(BluetoothGatt gatt, int interval, int latency, int timeout, int status) {
            android.util.Log.d(TAG, "=== onConnectionParametersUpdated 被调用 ===");
            android.util.Log.d(TAG, "Android版本: " + Build.VERSION.SDK_INT);
            android.util.Log.d(TAG, "设备地址: " + gatt.getDevice().getAddress());
            android.util.Log.d(TAG, "原始参数 - 间隔: " + interval + ", 延迟: " + latency + ", 超时: " + timeout + ", 状态: " + status);
            
            if (status == BluetoothGatt.GATT_SUCCESS) {
                android.util.Log.d(TAG, "✅ 连接参数更新成功 - 间隔: " + interval + "ms, 延迟: " + latency + ", 超时: " + timeout + "ms");
                
                // 计算实际的连接间隔（以毫秒为单位）
                // interval是以1.25ms为单位的，所以需要乘以1.25
                double actualIntervalMs = interval * 1.25;
                
                // 通知OtaManager更新连接参数
                OtaManager.getInstance().updateConnectionParameters(actualIntervalMs, latency, timeout);
                
                android.util.Log.d(TAG, "实际连接间隔: " + actualIntervalMs + "ms");
                android.util.Log.d(TAG, "连接延迟: " + latency + " (跳过的连接事件数)");
                android.util.Log.d(TAG, "连接超时: " + timeout + "ms");
                
            } else {
                android.util.Log.w(TAG, "❌ 连接参数更新失败: " + status);
            }
            android.util.Log.d(TAG, "=== onConnectionParametersUpdated 结束 ===");
        }

        @Override
        public void onCharacteristicRead(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
            android.util.Log.d(TAG, "onCharacteristicRead: uuid=" + characteristic.getUuid() + ", status=" + status);
            
            if (status == BluetoothGatt.GATT_SUCCESS) {
                byte[] data = characteristic.getValue();
                UUID characteristicUuid = characteristic.getUuid();
                
                // 处理电池电量数据
                if ("00002a19-0000-1000-8000-00805f9b34fb".equals(characteristicUuid.toString())) {
                    android.util.Log.d(TAG, "收到电池电量数据: " + bytesToHex(data));
                    
                    // 在BleManager中直接处理电池电量数据
                    if (data != null && data.length > 0) {
                        batteryLevel = data[0] & 0xFF;
                        lastBatteryUpdateTime = System.currentTimeMillis();
                        android.util.Log.d(TAG, "电池电量已更新: " + batteryLevel + "%");
                        if (batteryLevelListener != null) {
                            batteryLevelListener.onBatteryLevelUpdated(batteryLevel, lastBatteryUpdateTime);
                        }
                    }
                    return;
                }
                
                android.util.Log.d(TAG, "特征读取成功: " + characteristicUuid + ", 数据: " + bytesToHex(data));
            } else {
                android.util.Log.e(TAG, "特征读取失败: " + characteristic.getUuid() + ", status=" + status);
                // ⭐ 修复：移除电池电量读取失败时的重试机制，避免频繁重试导致连接不稳定
                // 如果是电池电量读取失败，不再重试，避免影响连接稳定性
                // if ("00002a19-0000-1000-8000-00805f9b34fb".equals(characteristic.getUuid().toString())) {
                //     android.util.Log.d(TAG, "电池电量读取失败，将在1秒后重试");
                //     mainHandler.postDelayed(() -> {
                //         if (isConnected && bluetoothGatt != null) {
                //             readBatteryLevel();
                //         }
                //     }, 1000);
                // }
            }
        }
    };
    
    // 私有构造函数
    private BleManager() {
        mainHandler = new Handler(Looper.getMainLooper());
        // 移除AudioProcessor的创建，改为通过setAudioProcessor方法设置
        // audioProcessor = new AudioProcessor();
        // audioProcessor.setCallback(new AudioProcessor.AudioProcessorCallback() {
        //     @Override
        //     public void onAudioDataReceived(byte[] audioData, boolean isEndFrame) {
        //         // 转发给数据监听器
        //         if (dataListener != null) {
        //             dataListener.onAudioDataReceived(audioData, isEndFrame);
        //         }
        //     }
        //     
        //     @Override
        //     public void onRecognitionResult(String result) {
        //         // 转发给数据监听器
        //         if (dataListener != null) {
        //             dataListener.onRecognitionResult(result);
        //         }
        //         
        //         // 通过BleForegroundService发送广播到悬浮窗
        //         if (context instanceof BleForegroundService) {
        //             try {
        //                 Intent intent = new Intent("com.smart.translator.ASR_RESULT");
        //                 intent.putExtra("asr_text", result);
        //                 context.sendBroadcast(intent);
        //                 android.util.Log.d(TAG, "通过BleForegroundService发送ASR结果到悬浮窗: " + result);
        //             } catch (Exception e) {
        //                 android.util.Log.e(TAG, "通过BleForegroundService发送ASR结果到悬浮窗失败", e);
        //             }
        //         } else {
        //             // 如果context不是BleForegroundService，尝试直接发送
        //             if (context != null) {
        //                 try {
        //                     Intent intent = new Intent("com.smart.translator.ASR_RESULT");
        //                     intent.putExtra("asr_text", result);
        //                     context.sendBroadcast(intent);
        //                     android.util.Log.d(TAG, "直接发送ASR结果到悬浮窗: " + result);
        //                 } catch (Exception e) {
        //                     android.util.Log.e(TAG, "直接发送ASR结果到悬浮窗失败", e);
        //                 }
        //             }
        //         }
        //     }
        //     
        //     @Override
        //     public void onPcmDataProcessed(byte[] pcmData) {
        //         // FFF4音频数据处理完成，可以在这里添加播放逻辑
        //         android.util.Log.d(TAG, "FFF4 PCM数据处理完成，长度: " + pcmData.length);
        //     }
        //     
        //     @Override
        //     public void onWavDataReady(byte[] wavPcmData) {
        //         // WAV数据准备完成，可以在这里添加保存或播放逻辑
        //         android.util.Log.d(TAG, "WAV数据准备完成，长度: " + wavPcmData.length);
        //     }
        //     
        //     @Override
        //     public void onTtsStatusChanged(boolean connected) {
        //         android.util.Log.d(TAG, "TTS状态变化: " + connected);
        //     }
        //     
        //     @Override
        //     public void onWebSocketStatusChanged(boolean connected) {
        //         android.util.Log.d(TAG, "WebSocket状态变化: " + connected);
        //     }
        //     
        //     @Override
        //     public void onAudioPlaybackStarted() {
        //         android.util.Log.d(TAG, "音频播放开始");
        //     }
        //     
        //     @Override
        //     public void onAudioPlaybackCompleted() {
        //         android.util.Log.d(TAG, "音频播放完成");
        //     }
        //     
        //     @Override
        //     public void onAudioFileSaved(String filePath) {
        //         android.util.Log.d(TAG, "音频文件已保存: " + filePath);
        //     }
        //     
        //     @Override
        //     public void onEncodeTestCompleted(byte[] encodedData) {
        //         android.util.Log.d(TAG, "编码测试完成，长度: " + (encodedData != null ? encodedData.length : 0));
        //     }
        //     
        //     @Override
        //     public void onDecodeTestCompleted(byte[] decodedData) {
        //         android.util.Log.d(TAG, "解码测试完成，长度: " + (encodedData != null ? encodedData.length : 0));
        //     }
        // });
    }
    
    /**
     * 设置AudioProcessor实例
     */
    public void setAudioProcessor(AudioProcessor processor) {
        this.audioProcessor = processor;
        android.util.Log.d(TAG, "AudioProcessor已设置");
    }
    
    // 获取单例实例
    public static BleManager getInstance() {
        if (instance == null) {
            synchronized (BleManager.class) {
                if (instance == null) {
                    instance = new BleManager();
                }
            }
        }
        return instance;
    }
    
    // 检查BLE权限
    private boolean checkBlePermissions() {
        boolean hasScanPermission = ActivityCompat.checkSelfPermission(context, Manifest.permission.BLUETOOTH_SCAN) == PackageManager.PERMISSION_GRANTED;
        boolean hasConnectPermission = ActivityCompat.checkSelfPermission(context, Manifest.permission.BLUETOOTH_CONNECT) == PackageManager.PERMISSION_GRANTED;
        
        android.util.Log.d(TAG, "BLE权限检查 - BLUETOOTH_SCAN: " + hasScanPermission + ", BLUETOOTH_CONNECT: " + hasConnectPermission);
        
        if (!hasScanPermission) {
            android.util.Log.e(TAG, "❌ 缺少BLUETOOTH_SCAN权限");
        }
        if (!hasConnectPermission) {
            android.util.Log.e(TAG, "❌ 缺少BLUETOOTH_CONNECT权限");
        }
        
        return hasScanPermission && hasConnectPermission;
    }
    
    // 初始化
    public void initialize(Context context) {
        if (isInitialized) {
            android.util.Log.d(TAG, "BleManager已经初始化");
            return;
        }
        
        this.context = context;
        this.mainHandler = new Handler(Looper.getMainLooper());
        this.prefs = context.getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE);
        
        // // 为AudioProcessor设置Context
        // if (audioProcessor != null) {
        //     audioProcessor.setContext(context);
        //     android.util.Log.d(TAG, "AudioProcessor Context已设置");
        // }
        
        // 检查权限
        if (!checkBlePermissions()) {
            android.util.Log.e(TAG, "BLE权限不足，初始化失败");
            return;
        }
        
        // 初始化蓝牙适配器
        BluetoothManager bluetoothManager = (BluetoothManager) context.getSystemService(Context.BLUETOOTH_SERVICE);
        if (bluetoothManager != null) {
            bluetoothAdapter = bluetoothManager.getAdapter();
            if (bluetoothAdapter != null) {
                bluetoothLeScanner = bluetoothAdapter.getBluetoothLeScanner();
                android.util.Log.d(TAG, "蓝牙适配器初始化成功");
            } else {
                android.util.Log.e(TAG, "蓝牙适配器不可用");
            }
        } else {
            android.util.Log.e(TAG, "蓝牙管理器不可用");
        }
        
        // ⭐ 修复：检查蓝牙是否真的可用
        if (bluetoothAdapter == null || !bluetoothAdapter.isEnabled()) {
            android.util.Log.w(TAG, "蓝牙适配器不可用或未启用，初始化失败");
            return;
        }
        
        // ⭐ 修复：添加蓝牙状态监听器
        try {
            // 先注销之前的监听器（如果存在）
            if (bluetoothStateReceiver != null && context != null) {
                try {
                    context.unregisterReceiver(bluetoothStateReceiver);
                    android.util.Log.d(TAG, "注销之前的蓝牙状态监听器");
                } catch (Exception e) {
                    android.util.Log.d(TAG, "注销之前的蓝牙状态监听器失败", e);
                }
            }
            
            android.content.IntentFilter filter = new android.content.IntentFilter(BluetoothAdapter.ACTION_STATE_CHANGED);
            bluetoothStateReceiver = new android.content.BroadcastReceiver() {
                @Override
                public void onReceive(Context context, android.content.Intent intent) {
                    String action = intent.getAction();
                    if (BluetoothAdapter.ACTION_STATE_CHANGED.equals(action)) {
                        int state = intent.getIntExtra(BluetoothAdapter.EXTRA_STATE, BluetoothAdapter.ERROR);
                        android.util.Log.d(TAG, "系统蓝牙状态变化: " + state);
                        
                        if (state == BluetoothAdapter.STATE_OFF) {
                            android.util.Log.w(TAG, "系统蓝牙已关闭，完全重置BleManager状态");
                            
                            // ⭐ 修复：完全重置BleManager状态和所有变量
                            // 1. 重置连接状态
                            isConnected = false;
                            isConnecting = false;
                            isScanning = false;
                            isUserDisconnected = false;
                            reconnectAttempts = 0;
                            
                            // 2. 清理GATT连接
                            if (bluetoothGatt != null) {
                                try {
                                    bluetoothGatt.close();
                                } catch (Exception e) {
                                    android.util.Log.e(TAG, "关闭GATT连接异常", e);
                                }
                                bluetoothGatt = null;
                            }
                            
                            // 3. 清理蓝牙适配器
                            bluetoothAdapter = null;
                            bluetoothLeScanner = null;
                            
                            // 4. 清理设备引用
                            connectedDevice = null;
                            
                            // 5. 清理特征引用
                            notifyCharacteristic = null;
                            writeCharacteristic = null;
                            fff3WriteCharacteristic = null;
                            
                            // 6. 清理通知相关状态
                            enabledNotifications.clear();
                            pendingNotifyQueue.clear();
                            isEnablingNotify = false;
                            notifyRetryCountMap.clear();
                            
                            // 7. 取消所有定时器
                            if (reconnectRunnable != null) {
                                mainHandler.removeCallbacks(reconnectRunnable);
                                reconnectRunnable = null;
                            }
                            if (connectionTimeoutRunnable != null) {
                                mainHandler.removeCallbacks(connectionTimeoutRunnable);
                                connectionTimeoutRunnable = null;
                            }
                            if (batteryUpdateRunnable != null) {
                                batteryUpdateHandler.removeCallbacks(batteryUpdateRunnable);
                                batteryUpdateRunnable = null;
                            }
                            
                            // 8. 重置电池电量状态
                            batteryLevel = -1;
                            lastBatteryUpdateTime = 0;
                            
                            // 9. 通知连接断开
                            if (connectionListener != null && connectedDevice != null) {
                                connectionListener.onDisconnected(connectedDevice);
                            }
                            
                            // 10. 更新服务通知
                            updateServiceNotification("系统蓝牙已关闭");
                            
                            // 11. 重置初始化状态（需要重新初始化）
                            isInitialized = false;
                            
                            android.util.Log.d(TAG, "BleManager状态已完全重置");
                        } else if (state == BluetoothAdapter.STATE_ON) {
                            android.util.Log.d(TAG, "系统蓝牙已开启，需要重新初始化BleManager");
                            // 系统蓝牙重新开启时，需要重新初始化
                            if (context != null) {
                                // 延迟重新初始化，确保蓝牙适配器已完全启动
                                mainHandler.postDelayed(() -> {
                                    try {
                                        android.util.Log.d(TAG, "系统蓝牙重新开启，重新初始化BleManager");
                                        initialize(context);
                                    } catch (Exception e) {
                                        android.util.Log.e(TAG, "重新初始化BleManager失败", e);
                                    }
                                }, 2000); // 延迟2秒重新初始化
                            }
                        }
                    }
                }
            };
            context.registerReceiver(bluetoothStateReceiver, filter);
            android.util.Log.d(TAG, "蓝牙状态监听器注册成功");
        } catch (Exception e) {
            android.util.Log.e(TAG, "注册蓝牙状态监听器失败", e);
        }
        
        isInitialized = true;
        android.util.Log.d(TAG, "BleManager初始化完成");
        
        // 尝试连接历史设备
        if (isDeviceInfoAutoConnectEnabled()) {
            tryConnectHistoryDevice();
        }
    }
    
    /**
     * 检查设备信息界面的自动连接开关状态
     */
    private boolean isDeviceInfoAutoConnectEnabled() {
        try {
            SharedPreferences switchPrefs = context.getSharedPreferences("switch_prefs", Context.MODE_PRIVATE);
            return switchPrefs.getBoolean("auto_connect_switch", false);
        } catch (Exception e) {
            android.util.Log.e(TAG, "检查设备信息界面自动连接开关状态失败", e);
            return false;
        }
    }
    
    /**
     * 尝试连接历史设备
     */
    private void tryConnectHistoryDevice() {
        try {
            // 检查用户是否主动断开连接
            if (isUserDisconnected) {
                android.util.Log.d(TAG, "用户主动断开连接，跳过自动连接");
                return;
            }
            
            // ⭐ 修复：使用新的getLastDeviceAddress方法获取历史设备地址
            String lastDeviceAddress = getLastDeviceAddress();
            
            if (lastDeviceAddress != null && !lastDeviceAddress.isEmpty()) {
                android.util.Log.d(TAG, "尝试连接历史设备: " + lastDeviceAddress);
                connectToHistoryDevice(lastDeviceAddress);
            } else {
                android.util.Log.d(TAG, "没有历史设备地址，跳过自动连接");
                // ⭐ 修复：确保没有历史设备时，连接状态为false，允许后续扫描
                isConnected = false;
                isConnecting = false;
                connectedDevice = null;
            }
        } catch (Exception e) {
            android.util.Log.e(TAG, "尝试连接历史设备失败", e);
            // ⭐ 修复：异常时也确保连接状态为false
            isConnected = false;
            isConnecting = false;
            connectedDevice = null;
        }
    }
    
    // 清理资源
    public void cleanup() {
        android.util.Log.d(TAG, "开始清理BleManager资源");
        
        // ⭐ 修复：注销蓝牙状态监听器
        if (bluetoothStateReceiver != null && context != null) {
            try {
                context.unregisterReceiver(bluetoothStateReceiver);
                bluetoothStateReceiver = null;
                android.util.Log.d(TAG, "蓝牙状态监听器已注销");
            } catch (Exception e) {
                android.util.Log.e(TAG, "注销蓝牙状态监听器失败", e);
            }
        }
        
        // 不要清理连接，保持长连接
        // 只清理扫描相关资源
        if (isScanning) {
            stopScan();
        }
        
        // 取消重连定时器
        if (reconnectRunnable != null) {
            mainHandler.removeCallbacks(reconnectRunnable);
            reconnectRunnable = null;
        }
        
        if (connectionTimeoutRunnable != null) {
            mainHandler.removeCallbacks(connectionTimeoutRunnable);
            connectionTimeoutRunnable = null;
        }
        
        // 清理音频处理器
        if (audioProcessor != null) {
            audioProcessor.cleanup();
        }
        
        // ⭐ 修复：只重置扫描和连接状态，保持初始化状态
        // 这样用户断开后仍可以扫描
        isScanning = false;
        isConnecting = false;
        // 不设置 isInitialized = false，保持基本初始化状态
        
        android.util.Log.d(TAG, "BleManager资源清理完成（保持初始化状态）");
    }
    
    // 开始扫描
    public void startScan() {
        // ⭐ 修复：如果未初始化，自动重新初始化
        if (!isInitialized) {
            android.util.Log.d(TAG, "BleManager未初始化，尝试重新初始化");
            if (context != null) {
                initialize(context);
            } else {
                android.util.Log.e(TAG, "无法重新初始化：context为null");
                return;
            }
        }
        
        // ⭐ 修复：修改扫描条件，允许在设备信息页面扫描
        if (isScanning) {
            android.util.Log.d(TAG, "扫描已在进行中");
            return;
        }
        
        // ⭐ 修复：如果正在连接中，阻止扫描
        if (isConnecting) {
            android.util.Log.d(TAG, "无法开始扫描: 正在连接中");
            return;
        }
        
        // ⭐ 修复：如果已连接设备，允许扫描但记录日志
        if (isConnected) {
            android.util.Log.d(TAG, "设备已连接，但仍然允许扫描以发现更多设备");
        }
        
        if (bluetoothLeScanner == null) {
            android.util.Log.e(TAG, "蓝牙扫描器不可用");
            return;
        }
        
        if (ActivityCompat.checkSelfPermission(context, Manifest.permission.BLUETOOTH_SCAN) != PackageManager.PERMISSION_GRANTED) {
            android.util.Log.e(TAG, "缺少蓝牙扫描权限");
            return;
        }
        
        // 设置扫描参数
        ScanSettings scanSettings = new ScanSettings.Builder()
                .setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY)
                .build();
        
        // 开始扫描
        try {
            bluetoothLeScanner.startScan(null, scanSettings, scanCallback);
            isScanning = true;
            android.util.Log.d(TAG, "开始扫描BLE设备");
            
            // 设置扫描超时
            mainHandler.postDelayed(new Runnable() {
                @Override
                public void run() {
                    if (isScanning) {
                        stopScan();
                    }
                }
            }, SCAN_PERIOD);
        } catch (Exception e) {
            android.util.Log.e(TAG, "开始扫描失败", e);
            isScanning = false;
        }
    }
    
    // 停止扫描
    public void stopScan() {
        if (!isScanning || bluetoothLeScanner == null) {
            return;
        }
        
        try {
            if (ActivityCompat.checkSelfPermission(context, Manifest.permission.BLUETOOTH_SCAN) == PackageManager.PERMISSION_GRANTED) {
                bluetoothLeScanner.stopScan(scanCallback);
            }
        } catch (Exception e) {
            android.util.Log.e(TAG, "停止扫描失败", e);
        }
        
        isScanning = false;
        android.util.Log.d(TAG, "停止扫描BLE设备");
    }
    
    // 连接到设备
    public void connectToDevice(BluetoothDevice device) {
        connectToDevice(device, false);
    }
    
    /**
     * 连接到指定设备
     * @param device 要连接的设备
     * @param forceReconnect 是否强制重连（用于OTA完成后重连）
     */
    public void connectToDevice(BluetoothDevice device, boolean forceReconnect) {
        if (!isInitialized) {
            android.util.Log.e(TAG, "无法连接设备: BleManager未初始化");
            return;
        }
        
        if (device == null) {
            android.util.Log.e(TAG, "设备为空，无法连接");
            return;
        }
        
        // 防止并发连接
        if (isConnecting || isConnected) {
            android.util.Log.d(TAG, "已在连接中或已连接，跳过本次连接");
            return;
        }
        
        // 如果正在连接，先彻底断开
        if (bluetoothGatt != null) {
            try { bluetoothGatt.disconnect(); } catch (Exception e) {}
            try { bluetoothGatt.close(); } catch (Exception e) {}
            bluetoothGatt = null;
        }
        
        android.util.Log.d(TAG, "开始连接设备: " + device.getAddress());
        
        // ⭐ 修复：在连接设备时保存历史设备地址
        saveLastDeviceAddress(device.getAddress());
        
        isConnecting = true;
        connectedDevice = device;
        reconnectAttempts = 0;
        isUserDisconnected = false;
        
        // 设置连接超时
        if (connectionTimeoutRunnable != null) {
            mainHandler.removeCallbacks(connectionTimeoutRunnable);
        }
        connectionTimeoutRunnable = new Runnable() {
            @Override
            public void run() {
                android.util.Log.w(TAG, "连接超时，取消连接");
                isConnecting = false;
                if (bluetoothGatt != null) {
                    try { bluetoothGatt.disconnect(); } catch (Exception e) {}
                    try { bluetoothGatt.close(); } catch (Exception e) {}
                    bluetoothGatt = null;
                }
                if (isAutoReconnectEnabled() && !isUserDisconnected) {
                    scheduleReconnect();
                }
            }
        };
        mainHandler.postDelayed(connectionTimeoutRunnable, CONNECTION_TIMEOUT);
        
        // 开始连接
        try {
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                bluetoothGatt = device.connectGatt(context, false, gattCallback, BluetoothDevice.TRANSPORT_LE);
            } else {
                bluetoothGatt = device.connectGatt(context, false, gattCallback);
            }
            if (bluetoothGatt == null) {
                android.util.Log.e(TAG, "创建GATT连接失败");
                isConnecting = false;
                if (isAutoReconnectEnabled() && !isUserDisconnected) {
                    scheduleReconnect();
                }
            }
        } catch (Exception e) {
            android.util.Log.e(TAG, "连接设备异常", e);
            isConnecting = false;
            if (isAutoReconnectEnabled() && !isUserDisconnected) {
                scheduleReconnect();
            }
        }
        
        updateServiceNotification("正在连接设备...");
    }
    
    // 断开连接（用户主动）
    public void disconnect() {
        android.util.Log.d(TAG, "用户主动断开连接");
        isUserDisconnected = true;

        // 真正断开BLE连接
        if (bluetoothGatt != null) {
            try {
                bluetoothGatt.disconnect();
            } catch (Exception e) {
                android.util.Log.e(TAG, "断开GATT连接异常", e);
            }
            try {
                bluetoothGatt.close();
            } catch (Exception e) {
                android.util.Log.e(TAG, "关闭GATT连接异常", e);
            }
            bluetoothGatt = null;
        }

        // 重置连接状态
        isConnected = false;
        isConnecting = false;
        connectedDevice = null;

        // 清理已启用通知的列表
        enabledNotifications.clear();
        android.util.Log.d(TAG, "已清理已启用通知列表");

        // 取消重连
        if (reconnectRunnable != null) {
            mainHandler.removeCallbacks(reconnectRunnable);
            reconnectRunnable = null;
        }

        if (connectionTimeoutRunnable != null) {
            mainHandler.removeCallbacks(connectionTimeoutRunnable);
            connectionTimeoutRunnable = null;
        }

        // 停止BLE前台服务
        if (context != null) {
            try {
                android.util.Log.d(TAG, "停止BLE前台服务");
                BleForegroundService.stopService(context);
            } catch (Exception e) {
                android.util.Log.e(TAG, "停止BLE前台服务失败", e);
            }
        }

        android.util.Log.d(TAG, "BLE连接已完全断开");
    }
    
    // 设置特征
    private void setupCharacteristics(BluetoothGatt gatt) {
        android.util.Log.d(TAG, "开始设置特征");
        notifyCharacteristic = null;
        writeCharacteristic = null;
        fff3WriteCharacteristic = null;
        
        // 清空队列和状态
        pendingNotifyQueue.clear();
        enabledNotifications.clear();
        isEnablingNotify = false;
        
        int serviceCount = 0;
        int characteristicCount = 0;
        
        // 第一步：扫描所有服务和特征，识别读写特征
        for (BluetoothGattService service : gatt.getServices()) {
            serviceCount++;
            android.util.Log.d(TAG, "发现服务 " + serviceCount + ": " + service.getUuid());
            
            for (BluetoothGattCharacteristic characteristic : service.getCharacteristics()) {
                characteristicCount++;
                int props = characteristic.getProperties();
                UUID charUuid = characteristic.getUuid();
                
                android.util.Log.d(TAG, String.format("特征 %d: %s, 属性: 0x%02X (NOTIFY: %b, WRITE: %b, WRITE_NO_RESPONSE: %b, INDICATE: %b)",
                    characteristicCount, charUuid, props,
                    (props & BluetoothGattCharacteristic.PROPERTY_NOTIFY) != 0,
                    (props & BluetoothGattCharacteristic.PROPERTY_WRITE) != 0,
                    (props & BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE) != 0,
                    (props & BluetoothGattCharacteristic.PROPERTY_INDICATE) != 0));
                
                // 查找FFF1特征（写特征，用于音频数据发送）
                if (FFF1_UUID.equals(charUuid)) {
                    android.util.Log.d(TAG, "找到FFF1特征");
                    if ((props & BluetoothGattCharacteristic.PROPERTY_WRITE) != 0 || 
                        (props & BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE) != 0) {
                        writeCharacteristic = characteristic;
                        android.util.Log.d(TAG, "成功设置FFF1写特征");
                    } else if ((props & BluetoothGattCharacteristic.PROPERTY_NOTIFY) != 0) {
                        notifyCharacteristic = characteristic;
                        android.util.Log.d(TAG, "成功设置FFF1通知特征");
                        // 加入Notify队列，统一处理
                        pendingNotifyQueue.add(characteristic);
                    } else {
                        android.util.Log.w(TAG, "FFF1特征既不支持WRITE也不支持NOTIFY属性");
                    }
                }
                
                // 查找FFF4特征（通知特征）
                if (FFF4_UUID.equals(charUuid)) {
                    android.util.Log.d(TAG, "找到FFF4特征");
                    if ((props & BluetoothGattCharacteristic.PROPERTY_NOTIFY) != 0) {
                        pendingNotifyQueue.add(characteristic);
                        android.util.Log.d(TAG, "FFF4特征加入notify队列");
                    } else {
                        android.util.Log.w(TAG, "FFF4特征不支持NOTIFY属性");
                    }
                }

                // 查找FFF6特征（按键通知特征）
                if (FFF6_UUID.equals(charUuid)) {
                    android.util.Log.d(TAG, "找到FFF6特征");
                    if ((props & BluetoothGattCharacteristic.PROPERTY_NOTIFY) != 0) {
                        pendingNotifyQueue.add(characteristic);
                        android.util.Log.d(TAG, "FFF6特征加入notify队列");
                    } else {
                        android.util.Log.w(TAG, "FFF6特征不支持NOTIFY属性");
                    }
                }
                
                // 查找FFF3特征（写特征，用于TTS音频输出）
                if (FFF3_UUID.equals(charUuid)) {
                    android.util.Log.d(TAG, "找到FFF3特征");
                    if ((props & BluetoothGattCharacteristic.PROPERTY_WRITE) != 0 || 
                        (props & BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE) != 0) {
                        fff3WriteCharacteristic = characteristic;
                        android.util.Log.d(TAG, "成功设置FFF3写特征");
                    } else {
                        android.util.Log.w(TAG, "FFF3特征不支持WRITE属性");
                    }
                }
                
                // 查找F2特征（写特征，备用）
                if (F2_UUID.equals(charUuid)) {
                    android.util.Log.d(TAG, "找到F2特征");
                    if ((props & BluetoothGattCharacteristic.PROPERTY_WRITE) != 0 || 
                        (props & BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE) != 0) {
                        // 如果FFF1还没有设置为写特征，则使用F2
                        if (writeCharacteristic == null) {
                            writeCharacteristic = characteristic;
                            android.util.Log.d(TAG, "成功设置F2写特征");
                        } else {
                            android.util.Log.d(TAG, "FFF1已设置为写特征，跳过F2");
                        }
                    } else {
                        android.util.Log.w(TAG, "F2特征不支持WRITE属性");
                    }
                }
                
                // 处理DSP OTA特征
                if (OTA_CHAR_UUID_NOTI_DSP.equals(charUuid)) {
                    android.util.Log.d(TAG, "找到DSP OTA通知特征");
                    if ((props & BluetoothGattCharacteristic.PROPERTY_NOTIFY) != 0) {
                        pendingNotifyQueue.add(characteristic);
                        android.util.Log.d(TAG, "DSP OTA通知特征加入notify队列");
                    } else {
                        android.util.Log.w(TAG, "DSP OTA通知特征不支持NOTIFY属性");
                    }
                }
                
                if (OTA_CHAR_UUID_RX_DSP.equals(charUuid)) {
                    android.util.Log.d(TAG, "找到DSP OTA接收特征");
                    if ((props & BluetoothGattCharacteristic.PROPERTY_NOTIFY) != 0) {
                        pendingNotifyQueue.add(characteristic);
                        android.util.Log.d(TAG, "DSP OTA接收特征加入notify队列");
                    } else {
                        android.util.Log.w(TAG, "DSP OTA接收特征不支持NOTIFY属性");
                    }
                }
                
                if (OTA_CHAR_UUID_TX_DSP.equals(charUuid)) {
                    android.util.Log.d(TAG, "找到DSP OTA发送特征");
                    if ((props & BluetoothGattCharacteristic.PROPERTY_WRITE) != 0 || 
                        (props & BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE) != 0) {
                        android.util.Log.d(TAG, "DSP OTA发送特征支持WRITE属性");
                    } else {
                        android.util.Log.w(TAG, "DSP OTA发送特征不支持WRITE属性");
                    }
                }
                
                // 处理CM3 OTA特征
                if (OTA_RECV_CHARACTERISTIC_UUID.equals(charUuid)) {
                    android.util.Log.d(TAG, "找到CM3 OTA接收特征");
                    if ((props & BluetoothGattCharacteristic.PROPERTY_NOTIFY) != 0) {
                        pendingNotifyQueue.add(characteristic);
                        android.util.Log.d(TAG, "CM3 OTA接收特征加入notify队列");
                    } else {
                        android.util.Log.w(TAG, "CM3 OTA接收特征不支持NOTIFY属性");
                    }
                }
                
                if (OTA_SEND_CHARACTERISTIC_UUID.equals(charUuid)) {
                    android.util.Log.d(TAG, "找到CM3 OTA发送特征");
                    if ((props & BluetoothGattCharacteristic.PROPERTY_WRITE) != 0 || 
                        (props & BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE) != 0) {
                        android.util.Log.d(TAG, "CM3 OTA发送特征支持WRITE属性");
                    } else {
                        android.util.Log.w(TAG, "CM3 OTA发送特征不支持WRITE属性");
                    }
                }
                
                // 处理外部Flash OTA特征
                if (OTA_CHAR_UUID_NOTI_EXTERNAL_FLASH.equals(charUuid)) {
                    android.util.Log.d(TAG, "找到外部Flash OTA通知特征");
                    if ((props & BluetoothGattCharacteristic.PROPERTY_NOTIFY) != 0) {
                        pendingNotifyQueue.add(characteristic);
                        android.util.Log.d(TAG, "外部Flash OTA通知特征加入notify队列");
                    } else {
                        android.util.Log.w(TAG, "外部Flash OTA通知特征不支持NOTIFY属性");
                    }
                }
                
                if (OTA_CHAR_UUID_RX_EXTERNAL_FLASH.equals(charUuid)) {
                    android.util.Log.d(TAG, "找到外部Flash OTA接收特征");
                    if ((props & BluetoothGattCharacteristic.PROPERTY_NOTIFY) != 0) {
                        pendingNotifyQueue.add(characteristic);
                        android.util.Log.d(TAG, "外部Flash OTA接收特征加入notify队列");
                    } else {
                        android.util.Log.w(TAG, "外部Flash OTA接收特征不支持NOTIFY属性");
                    }
                }
                
                if (OTA_CHAR_UUID_TX_EXTERNAL_FLASH.equals(charUuid)) {
                    android.util.Log.d(TAG, "找到外部Flash OTA发送特征");
                    if ((props & BluetoothGattCharacteristic.PROPERTY_WRITE) != 0 || 
                        (props & BluetoothGattCharacteristic.PROPERTY_WRITE_NO_RESPONSE) != 0) {
                        android.util.Log.d(TAG, "外部Flash OTA发送特征支持WRITE属性");
                    } else {
                        android.util.Log.w(TAG, "外部Flash OTA发送特征不支持WRITE属性");
                    }
                }
            }
        }
        
        android.util.Log.d(TAG, "特征扫描完成 - 服务数量: " + serviceCount + ", 特征数量: " + characteristicCount);
        android.util.Log.d(TAG, "需要使能Notify的特征数量: " + pendingNotifyQueue.size());
        
        // 检查特征设置结果
        if (notifyCharacteristic == null) {
            android.util.Log.w(TAG, "⚠️ 未找到FFF1通知特征，音频数据接收功能将不可用");
        } else {
            android.util.Log.i(TAG, "✅ FFF1通知特征设置成功");
        }
        
        if (fff3WriteCharacteristic == null) {
            android.util.Log.w(TAG, "⚠️ 未找到FFF3写特征，TTS音频输出功能将不可用");
        } else {
            android.util.Log.i(TAG, "✅ FFF3写特征设置成功");
        }
        
        if (writeCharacteristic == null) {
            android.util.Log.w(TAG, "⚠️ 未找到写特征，数据发送功能将不可用");
        } else {
            android.util.Log.i(TAG, "✅ 写特征设置成功: " + writeCharacteristic.getUuid());
        }
        
        android.util.Log.d(TAG, "特征设置完成");
        
        // 将BLE对象传递给AudioProcessor（用于TTS ADPCM数据写入）
        if (audioProcessor != null) {
            audioProcessor.setBleObjects(bluetoothGatt, fff3WriteCharacteristic);
            android.util.Log.d(TAG, "BLE对象已传递给AudioProcessor");
        } else {
            android.util.Log.w(TAG, "AudioProcessor为空，无法传递BLE对象");
        }
        
        // 第二步：统一串行使能所有Notify特征
        if (!pendingNotifyQueue.isEmpty()) {
            android.util.Log.d(TAG, "开始串行使能Notify特征，队列大小: " + pendingNotifyQueue.size());
            enableNextNotify(gatt);
        } else {
            android.util.Log.d(TAG, "没有需要使能的Notify特征");
        }
    }
    
    // 启用通知
    private void enableNotification(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
        if (gatt == null || characteristic == null) {
            android.util.Log.e(TAG, "enableNotification: gatt或characteristic为空");
            enableNextNotify(gatt); // 跳过，继续下一个
            return;
        }
        
        UUID charUuid = characteristic.getUuid();
        android.util.Log.d(TAG, "开始使能Notify: " + charUuid);
        
        // 检查是否已经使能过
        if (enabledNotifications.contains(charUuid)) {
            android.util.Log.d(TAG, "特征已使能Notify，跳过: " + charUuid);
            enableNextNotify(gatt);
            return;
        }
        
        // 设置特征通知
        boolean setResult = gatt.setCharacteristicNotification(characteristic, true);
        android.util.Log.d(TAG, "设置特征通知: " + charUuid + ", 结果: " + setResult);
        
        if (!setResult) {
            android.util.Log.e(TAG, "设置特征通知失败: " + charUuid);
            enableNextNotify(gatt);
            return;
        }
        
        // 查找通知描述符
        BluetoothGattDescriptor descriptor = characteristic.getDescriptor(UUID.fromString("00002902-0000-1000-8000-00805f9b34fb"));
        if (descriptor == null) {
            android.util.Log.e(TAG, "未找到通知描述符: " + charUuid);
            enableNextNotify(gatt); // 跳过，继续下一个
            return;
        }
        
        // 设置描述符值
        descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
        boolean writeResult = gatt.writeDescriptor(descriptor);
        
        if (!writeResult) {
            int retry = notifyRetryCountMap.getOrDefault(charUuid, 0);
            if (retry < MAX_NOTIFY_RETRY) {
                notifyRetryCountMap.put(charUuid, retry + 1);
                android.util.Log.w(TAG, "写入通知描述符失败，重试: " + (retry + 1) + ", uuid: " + charUuid);
                mainHandler.postDelayed(() -> enableNotification(gatt, characteristic), NOTIFY_RETRY_DELAY_MS);
            } else {
                android.util.Log.e(TAG, "写入通知描述符最终失败: " + charUuid + ", 重试次数: " + retry);
                notifyRetryCountMap.remove(charUuid);
                enableNextNotify(gatt);
            }
        } else {
            android.util.Log.d(TAG, "通知描述符写入请求已发送: " + charUuid);
            // 注意：实际的使能结果会在onDescriptorWrite回调中处理
        }
    }
    
    // 串行enable notify方法
    private void enableNextNotify(BluetoothGatt gatt) {
        if (isEnablingNotify) {
            android.util.Log.d(TAG, "正在使能Notify中，跳过重复调用");
            return;
        }
        
        if (pendingNotifyQueue.isEmpty()) {
            android.util.Log.d(TAG, "Notify队列为空，所有特征使能完成");
            isEnablingNotify = false;
            return;
        }
        
        isEnablingNotify = true;
        BluetoothGattCharacteristic charToEnable = pendingNotifyQueue.poll();
        
        if (charToEnable != null) {
            android.util.Log.d(TAG, "处理下一个Notify特征: " + charToEnable.getUuid() + ", 队列剩余: " + pendingNotifyQueue.size());
            enableNotification(gatt, charToEnable);
        } else {
            android.util.Log.d(TAG, "队列中的特征为空，结束Notify使能");
            isEnablingNotify = false;
        }
    }
    
    // 写入数据
    public boolean writeData(byte[] data) {
        if (!isConnected || writeCharacteristic == null || bluetoothGatt == null) {
            android.util.Log.e(TAG, "无法写入数据: 未连接或写特征不可用");
            return false;
        }
        
        if (ActivityCompat.checkSelfPermission(context, Manifest.permission.BLUETOOTH_CONNECT) != PackageManager.PERMISSION_GRANTED) {
            android.util.Log.e(TAG, "缺少BLUETOOTH_CONNECT权限");
            return false;
        }
        
        try {
            writeCharacteristic.setValue(data);
            return bluetoothGatt.writeCharacteristic(writeCharacteristic);
        } catch (Exception e) {
            android.util.Log.e(TAG, "写入数据失败", e);
            return false;
        }
    }
    
    // 写入FFF3数据
    public boolean writeFff3Data(byte[] data) {
        if (!isConnected || fff3WriteCharacteristic == null) {
            android.util.Log.w(TAG, "无法写入FFF3数据: 未连接或特征未找到");
            return false;
        }
        
        try {
            fff3WriteCharacteristic.setValue(data);
            boolean result = bluetoothGatt.writeCharacteristic(fff3WriteCharacteristic);
            android.util.Log.d(TAG, "FFF3数据写入请求: " + result + ", 数据长度: " + data.length);
            return result;
        } catch (Exception e) {
            android.util.Log.e(TAG, "FFF3数据写入异常", e);
            return false;
        }
    }
    
    // 设备过滤
    private boolean shouldConnectToDevice(BluetoothDevice device) {
        if (device == null) return false;
        
        String name = device.getName();
        if (name == null) name = "";
        
        // 只连接白名单设备
        List<String> allowedDeviceNames = new ArrayList<>();
        allowedDeviceNames.add("Hear Me BLE");
        
        return allowedDeviceNames.contains(name);
    }
    
    // 安排重连
    private void scheduleReconnect() {
        if (isUserDisconnected || !isAutoReconnectEnabled()) {
            android.util.Log.d(TAG, "跳过重连: 用户主动断开或自动重连已禁用");
            return;
        }
        if (isConnecting || isConnected) {
            android.util.Log.d(TAG, "重连时已在连接中或已连接，跳过本次重连");
            return;
        }
        if (reconnectAttempts >= MAX_RECONNECT_ATTEMPTS) {
            android.util.Log.w(TAG, "达到最大重连次数，停止重连");
            updateServiceNotification("连接失败，请手动重试");
            return;
        }
        
        // ⭐ 修复：检查是否有历史设备
        if (connectedDevice == null) {
            // 尝试从历史记录获取设备地址
            SharedPreferences devicePrefs = context.getSharedPreferences("ble_history", Context.MODE_PRIVATE);
            String lastDeviceAddress = devicePrefs.getString("last_device", null);
            
            if (lastDeviceAddress == null || lastDeviceAddress.isEmpty()) {
                android.util.Log.d(TAG, "跳过重连: 没有历史设备");
                updateServiceNotification("连接断开");
                return;
            }
            
            // 尝试获取设备对象
            if (bluetoothAdapter != null) {
                connectedDevice = bluetoothAdapter.getRemoteDevice(lastDeviceAddress);
                android.util.Log.d(TAG, "从历史记录获取设备: " + lastDeviceAddress);
            } else {
                android.util.Log.w(TAG, "蓝牙适配器不可用，无法重连");
                updateServiceNotification("连接断开");
                return;
            }
        }
        
        reconnectAttempts++;
        android.util.Log.d(TAG, "安排重连，第 " + reconnectAttempts + " 次尝试");
        // 指数退避策略：2秒、4秒、8秒、10秒（最大10秒）
        long delay = Math.min(RECONNECT_DELAY * (1L << (reconnectAttempts - 1)), 10000L);
        if (reconnectRunnable != null) {
            mainHandler.removeCallbacks(reconnectRunnable);
        }
        reconnectRunnable = new Runnable() {
            @Override
            public void run() {
                android.util.Log.d(TAG, "执行重连");
                if (connectedDevice != null && !isUserDisconnected && !isConnecting && !isConnected) {
                    isConnecting = false; // 重置连接状态
                    connectToDevice(connectedDevice);
                } else {
                    android.util.Log.d(TAG, "重连时状态异常，跳过本次重连");
                }
            }
        };
        mainHandler.postDelayed(reconnectRunnable, delay);
        updateServiceNotification("正在重连设备... (第" + reconnectAttempts + "次)");
    }
    
    // 更新服务通知
    private void updateServiceNotification(String status) {
        android.util.Log.d(TAG, "更新服务通知: " + status);
        if (context instanceof BleForegroundService) {
            ((BleForegroundService) context).updateNotification(status);
        }
    }
    

    

    
    // 设置自动重连
    public void setAutoReconnect(boolean enabled) {
        prefs.edit().putBoolean(KEY_AUTO_RECONNECT, enabled).apply();
    }
    
    // 是否启用自动重连
    private boolean isAutoReconnectEnabled() {
        return prefs.getBoolean(KEY_AUTO_RECONNECT, true);
    }
    
    // 设置连接监听器
    public void setConnectionListener(BleConnectionListener listener) {
        this.connectionListener = listener;
    }
    
    // 设置数据监听器
    public void setDataListener(BleDataListener listener) {
        this.dataListener = listener;
    }
    
    // 设置电池电量更新监听器
    public void setBatteryLevelListener(BatteryLevelListener listener) {
        this.batteryLevelListener = listener;
    }
    
    // ⭐ 新增：设置扫描结果监听器
    public void setScanResultListener(ScanResultListener listener) {
        this.scanResultListener = listener;
    }
    
    // 获取连接状态
    public boolean isConnected() {
        android.util.Log.d(TAG, "检查连接状态 - isConnected: " + isConnected + ", bluetoothGatt: " + (bluetoothGatt != null) + ", isUserDisconnected: " + isUserDisconnected);
        
        // ⭐ 修复：检查系统蓝牙是否可用
        if (bluetoothAdapter == null || !bluetoothAdapter.isEnabled()) {
            android.util.Log.d(TAG, "系统蓝牙不可用，返回false");
            return false;
        }
        
        // ⭐ 修复：检查蓝牙适配器是否真的可用
        try {
            if (!bluetoothAdapter.isEnabled()) {
                android.util.Log.d(TAG, "蓝牙适配器未启用，返回false");
                return false;
            }
        } catch (Exception e) {
            android.util.Log.e(TAG, "检查蓝牙适配器状态异常", e);
            return false;
        }
        
        // ⭐ 修复：只有在真正连接时才返回true
        if (isConnected && bluetoothGatt != null && !isUserDisconnected) {
            return true;
        }
        
        return false;
    }
    
    // ⭐ 新增：获取蓝牙适配器
    public BluetoothAdapter getBluetoothAdapter() {
        return bluetoothAdapter;
    }
    
    // 获取连接设备
    public BluetoothDevice getConnectedDevice() {
        return connectedDevice;
    }
    
    // 获取扫描状态
    public boolean isScanning() {
        return isScanning;
    }
    
    // 设置接口版本
    public void setUseSpeechV3(boolean useV3) {
        if (audioProcessor != null) {
            audioProcessor.setUseSpeechV3(useV3);
        }
    }
    
    // 新增：外部模块可调用，加入notify队列
    public void addNotifyCharacteristic(BluetoothGattCharacteristic characteristic) {
        if (characteristic == null) return;
        if (pendingNotifyQueue.contains(characteristic) || enabledNotifications.contains(characteristic.getUuid())) {
            android.util.Log.d(TAG, characteristic.getUuid() + " 已在notify队列或已启用，跳过");
            return;
        }
        pendingNotifyQueue.add(characteristic);
        android.util.Log.d(TAG, characteristic.getUuid() + " 特征通过addNotifyCharacteristic加入notify队列");
    }
    
    // 连接监听器接口
    public interface BleConnectionListener {
        void onConnected(BluetoothDevice device);
        void onDisconnected(BluetoothDevice device);
    }
    
    // 数据监听器接口
    public interface BleDataListener {
        void onDataReceived(UUID characteristicUuid, byte[] data);
        
        // 新增音频数据回调
        void onAudioDataReceived(byte[] audioData, boolean isEndFrame);
        
        // 新增识别结果回调
        void onRecognitionResult(String result);
    }
    
    // 电池电量更新监听器接口
    public interface BatteryLevelListener {
        void onBatteryLevelUpdated(int batteryLevel, long timestamp);
    }
    
    // ⭐ 新增：扫描结果监听器接口
    public interface ScanResultListener {
        void onScanResult(BluetoothDevice device, int rssi);
        void onScanFailed(int errorCode);
    }
    
    private BatteryLevelListener batteryLevelListener;
    private ScanResultListener scanResultListener; // ⭐ 新增：扫描结果监听器
    
    // ⭐ 修复：添加蓝牙状态监听器成员变量
    private android.content.BroadcastReceiver bluetoothStateReceiver;
    
    // 辅助方法：字节转16进制字符串
    // private String bytesToHex(byte[] bytes) {
    //     if (bytes == null || bytes.length == 0) {
    //         return "空数据";
    //     }
    //     StringBuilder sb = new StringBuilder();
    //     for (int i = 0; i < Math.min(bytes.length, 20); i++) { // 只显示前20字节
    //         sb.append(String.format("%02X ", bytes[i]));
    //     }
    //     if (bytes.length > 20) {
    //         sb.append("...");
    //     }
    //     return sb.toString();
    // }
    
    // 新增：字节数组转16进制字符串
    private String bytesToHex(byte[] bytes) {
        if (bytes == null) return "null";
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) {
            sb.append(String.format("%02X ", b));
        }
        return sb.toString().trim();
    }
    
    // 获取连接状态信息
    public String getConnectionStatus() {
        StringBuilder status = new StringBuilder();
        status.append("BleManager状态:\n");
        status.append("- 初始化: ").append(isInitialized).append("\n");
        status.append("- 扫描中: ").append(isScanning).append("\n");
        status.append("- 连接中: ").append(isConnecting).append("\n");
        status.append("- 已连接: ").append(isConnected).append("\n");
        status.append("- 用户断开: ").append(isUserDisconnected).append("\n");
        status.append("- 重连次数: ").append(reconnectAttempts).append("\n");
        
        if (connectedDevice != null) {
            status.append("- 连接设备: ").append(connectedDevice.getAddress()).append("\n");
            if (ActivityCompat.checkSelfPermission(context, Manifest.permission.BLUETOOTH_CONNECT) == PackageManager.PERMISSION_GRANTED) {
                status.append("- 设备名称: ").append(connectedDevice.getName()).append("\n");
            }
        }
        
        status.append("- FFF1通知特征: ").append(notifyCharacteristic != null ? "已设置" : "未设置").append("\n");
        status.append("- 写特征: ").append(writeCharacteristic != null ? "已设置(" + writeCharacteristic.getUuid() + ")" : "未设置").append("\n");
        status.append("- FFF3写特征: ").append(fff3WriteCharacteristic != null ? "已设置" : "未设置").append("\n");
        
        return status.toString();
    }
    
    // 强制重新连接
    public void forceReconnect() {
        android.util.Log.d(TAG, "强制重新连接");
        isUserDisconnected = false;
        reconnectAttempts = 0;
        
        if (bluetoothGatt != null) {
            bluetoothGatt.close();
            bluetoothGatt = null;
        }
        
        isConnected = false;
        isConnecting = false;
        
        if (connectedDevice != null) {
            connectToDevice(connectedDevice);
        }
    }
    
    // 测试连接
    public void testConnection() {
        android.util.Log.d(TAG, "=== BLE连接测试 ===");
        android.util.Log.d(TAG, getConnectionStatus());
        
        if (!isInitialized) {
            android.util.Log.e(TAG, "BleManager未初始化");
            return;
        }
        
        if (!checkBlePermissions()) {
            android.util.Log.e(TAG, "BLE权限不足");
            return;
        }
        
        if (bluetoothAdapter == null) {
            android.util.Log.e(TAG, "蓝牙适配器不可用");
            return;
        }
        
        if (!bluetoothAdapter.isEnabled()) {
            android.util.Log.e(TAG, "蓝牙未启用");
            return;
        }
        
        android.util.Log.d(TAG, "蓝牙状态正常，开始扫描设备...");
        startScan();
    }
    
    // 测试数据发送
    public void testDataSend() {
        if (!isConnected) {
            android.util.Log.w(TAG, "设备未连接，无法发送测试数据");
            return;
        }
        
        // 发送测试数据
        byte[] testData = {0x01, 0x02, 0x03, 0x04, 0x05};
        boolean success = writeData(testData);
        android.util.Log.d(TAG, "测试数据发送: " + success);
    }
    
    /**
     * 获取BluetoothGatt实例（供OTA管理器使用）
     */
    public BluetoothGatt getBluetoothGatt() {
        return bluetoothGatt;
    }
    
    /**
     * 获取当前电池电量
     */
    public int getBatteryLevel() {
        return batteryLevel;
    }
    
    /**
     * 获取电池电量更新时间
     */
    public long getLastBatteryUpdateTime() {
        return lastBatteryUpdateTime;
    }
    
    /**
     * 检查是否需要更新电池电量
     */
    public boolean shouldUpdateBatteryLevel() {
        return System.currentTimeMillis() - lastBatteryUpdateTime > BATTERY_UPDATE_INTERVAL;
    }
    
    /**
     * 读取设备电池电量
     */
    public void readBatteryLevel() {
        try {
            // 检查连接状态
            if (!isConnected || bluetoothGatt == null) {
                android.util.Log.d(TAG, "BLE未连接，跳过电池电量读取 - isConnected: " + isConnected + ", bluetoothGatt: " + (bluetoothGatt != null));
                return;
            }
            
            // 检查OTA状态，如果正在OTA升级则跳过电量读取
            OtaManager otaManager = OtaManager.getInstance();
            if (otaManager != null && (otaManager.getCurrentState() == OtaManager.OTA_STATE_UPDATING || otaManager.isUpdating())) {
                android.util.Log.d(TAG, "OTA升级正在进行中，跳过电量读取");
                return;
            }
            
            // 查找电池服务
            BluetoothGattService batteryService = bluetoothGatt.getService(
                UUID.fromString("0000180f-0000-1000-8000-00805f9b34fb")); // 标准电池服务UUID
            
            if (batteryService == null) {
                android.util.Log.d(TAG, "未找到电池服务，跳过电池电量读取");
                return;
            }
            
            // 查找电池电量特征
            BluetoothGattCharacteristic batteryLevelChar = batteryService.getCharacteristic(
                UUID.fromString("00002a19-0000-1000-8000-00805f9b34fb")); // 标准电池电量特征UUID
            
            if (batteryLevelChar == null) {
                android.util.Log.d(TAG, "未找到电池电量特征，跳过电池电量读取");
                return;
            }
            
            // 检查特征是否可读
            if ((batteryLevelChar.getProperties() & BluetoothGattCharacteristic.PROPERTY_READ) == 0) {
                android.util.Log.w(TAG, "电池电量特征不支持读取");
                return;
            }
            
            // ⭐ 修复：添加连接状态检查，确保在读取前连接仍然稳定
            if (!isConnected || bluetoothGatt == null) {
                android.util.Log.w(TAG, "连接状态不稳定，跳过电池电量读取");
                return;
            }
            
            // 读取电池电量
            boolean success = bluetoothGatt.readCharacteristic(batteryLevelChar);
            if (success) {
                android.util.Log.d(TAG, "已发送电池电量读取请求");
            } else {
                android.util.Log.w(TAG, "电池电量读取请求失败");
                // ⭐ 修复：移除自动重试，避免频繁重试导致连接不稳定
                // 如果读取失败，不进行重试，避免影响连接稳定性
                // mainHandler.postDelayed(() -> {
                //     if (isConnected && bluetoothGatt != null) {
                //         android.util.Log.d(TAG, "重试电池电量读取");
                //         readBatteryLevel();
                //     }
                // }, 1000); // 1秒后重试
            }
            
        } catch (Exception e) {
            android.util.Log.e(TAG, "读取电池电量异常", e);
            // ⭐ 修复：异常时不进行重试，避免影响连接稳定性
        }
    }
    
    /**
     * 测试连接参数更新（调试用）
     */
    public void testConnectionParametersUpdate() {
        if (!isConnected || bluetoothGatt == null) {
            android.util.Log.w(TAG, "设备未连接，无法测试连接参数更新");
            return;
        }
        
        android.util.Log.d(TAG, "=== 开始测试连接参数更新 ===");
        android.util.Log.d(TAG, "Android版本: " + Build.VERSION.SDK_INT);
        android.util.Log.d(TAG, "连接参数更新支持: " + (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O));
        
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
            try {
                android.util.Log.d(TAG, "发送连接参数更新请求...");
                bluetoothGatt.requestConnectionPriority(BluetoothGatt.CONNECTION_PRIORITY_HIGH);
                android.util.Log.d(TAG, "连接参数更新请求已发送");
            } catch (Exception e) {
                android.util.Log.e(TAG, "发送连接参数更新请求失败", e);
            }
        } else {
            android.util.Log.w(TAG, "当前Android版本不支持连接参数更新");
        }
        
        android.util.Log.d(TAG, "=== 连接参数更新测试完成 ===");
    }
    
    /**
     * 清除历史设备记录
     * 供DeviceFragment删除设备时调用
     */
    public void clearLastDeviceAddress() {
        android.util.Log.d(TAG, "清除历史设备记录");
        connectedDevice = null;
        isUserDisconnected = true; // 标记为用户主动断开，避免自动重连
        
        // 清除BleManager自己的SharedPreferences中的历史设备地址
        if (prefs != null) {
            SharedPreferences.Editor editor = prefs.edit();
            editor.remove(KEY_LAST_DEVICE_ADDRESS);
            editor.apply();
            android.util.Log.d(TAG, "已清除BleManager SharedPreferences中的历史设备地址");
        }
        
        // 同时清除DeviceFragment使用的SharedPreferences中的历史设备地址
        if (context != null) {
            SharedPreferences devicePrefs = context.getSharedPreferences("ble_history", Context.MODE_PRIVATE);
            SharedPreferences.Editor deviceEditor = devicePrefs.edit();
            deviceEditor.remove("last_device");
            // ⭐ 修复：清除整个history_device_set，因为用户主动删除了所有历史设备
            deviceEditor.remove("history_device_set");
            deviceEditor.apply();
            android.util.Log.d(TAG, "已清除DeviceFragment SharedPreferences中的历史设备地址和history_device_set");
        }
        
        android.util.Log.d(TAG, "已设置用户主动断开标记");
    }
    
    /**
     * 设置用户主动断开标记
     * 用于防止自动重连
     */
    public void setUserDisconnected(boolean userDisconnected) {
        this.isUserDisconnected = userDisconnected;
        android.util.Log.d(TAG, "设置用户主动断开标记: " + userDisconnected);
    }
    
    /**
     * 获取用户主动断开标记
     * 用于检查是否为用户主动断开
     */
    public boolean isUserDisconnected() {
        return isUserDisconnected;
    }
    
    /**
     * 连接到指定的历史设备
     * 供DeviceFragment调用，用于自动重连
     */
    public void connectToHistoryDevice(String deviceAddress) {
        connectToHistoryDevice(deviceAddress, false);
    }
    
    /**
     * 连接到指定的历史设备
     * @param deviceAddress 设备地址
     * @param forceReconnect 是否强制重连（用于OTA完成后重连）
     */
    public void connectToHistoryDevice(String deviceAddress, boolean forceReconnect) {
        if (deviceAddress == null || deviceAddress.isEmpty()) {
            android.util.Log.d(TAG, "历史设备地址为空，跳过连接");
            return;
        }
        
        if (bluetoothAdapter == null) {
            android.util.Log.e(TAG, "蓝牙适配器不可用，无法连接历史设备");
            return;
        }
        
        try {
            android.util.Log.d(TAG, "尝试连接历史设备: " + deviceAddress + (forceReconnect ? " (强制重连)" : ""));
            BluetoothDevice device = bluetoothAdapter.getRemoteDevice(deviceAddress);
            connectToDevice(device, forceReconnect);
        } catch (Exception e) {
            android.util.Log.e(TAG, "连接历史设备失败", e);
        }
    }
    
    /**
     * 启动电池电量自动更新
     */
    public void startBatteryAutoUpdate() {
        // ⭐ 修复：添加连接状态检查，确保只有在连接时才启动电池电量自动更新
        if (!isConnected || bluetoothGatt == null) {
            android.util.Log.w(TAG, "设备未连接，跳过电池电量自动更新启动");
            return;
        }
        
        // 停止之前的定时器
        if (batteryUpdateRunnable != null) {
            batteryUpdateHandler.removeCallbacks(batteryUpdateRunnable);
        }
        
        batteryUpdateRunnable = new Runnable() {
            @Override
            public void run() {
                // ⭐ 修复：每次执行前都检查连接状态
                if (isConnected && bluetoothGatt != null) {
                    android.util.Log.d(TAG, "自动读取电池电量");
                    readBatteryLevel();
                    // 继续定时更新
                    batteryUpdateHandler.postDelayed(this, BATTERY_UPDATE_INTERVAL);
                } else {
                    android.util.Log.w(TAG, "设备已断开，停止电池电量自动更新");
                    // 连接断开时停止定时器
                    stopBatteryAutoUpdate();
                }
            }
        };
        
        batteryUpdateHandler.postDelayed(batteryUpdateRunnable, BATTERY_UPDATE_INTERVAL);
        android.util.Log.d(TAG, "电池电量自动更新已启动");
    }
    
    /**
     * 停止电池电量自动更新
     */
    public void stopBatteryAutoUpdate() {
        if (batteryUpdateRunnable != null) {
            batteryUpdateHandler.removeCallbacks(batteryUpdateRunnable);
            batteryUpdateRunnable = null;
            android.util.Log.d(TAG, "电池电量自动更新已停止");
        }
    }
    
    /**
     * 连接到最后一个连接的设备
     * 供BleForegroundService调用，用于自动重连
     */
    public void connectToLastDevice() {
        connectToLastDevice(false);
    }
    
    /**
     * 连接到最后一个连接的设备
     * @param forceReconnect 是否强制重连（用于OTA完成后重连）
     */
    public void connectToLastDevice(boolean forceReconnect) {
        try {
            // ⭐ 修复：使用新的getLastDeviceAddress方法获取历史设备地址
            String lastDeviceAddress = getLastDeviceAddress();
            
            if (lastDeviceAddress != null && !lastDeviceAddress.isEmpty()) {
                android.util.Log.d(TAG, "找到历史设备地址: " + lastDeviceAddress + (forceReconnect ? " (强制重连)" : ""));
                connectToHistoryDevice(lastDeviceAddress, forceReconnect);
            } else {
                android.util.Log.d(TAG, "没有历史设备地址，跳过自动连接");
            }
        } catch (Exception e) {
            android.util.Log.e(TAG, "连接最后设备失败", e);
        }
    }
    
    /**
     * 获取最后连接的设备地址
     * 供OTA管理器使用，用于设备重启后重新连接
     */
    public String getLastConnectedDeviceAddress() {
        return getLastDeviceAddress();
    }
    
    /**
     * 调试方法：检查连接状态和GATT状态
     */
    public void debugConnectionStatus() {
        android.util.Log.d(TAG, "=== 连接状态调试信息 ===");
        android.util.Log.d(TAG, "isInitialized: " + isInitialized);
        android.util.Log.d(TAG, "isConnected: " + isConnected);
        android.util.Log.d(TAG, "isConnecting: " + isConnecting);
        android.util.Log.d(TAG, "isUserDisconnected: " + isUserDisconnected);
        android.util.Log.d(TAG, "bluetoothAdapter: " + (bluetoothAdapter != null));
        android.util.Log.d(TAG, "bluetoothGatt: " + (bluetoothGatt != null));
        android.util.Log.d(TAG, "connectedDevice: " + (connectedDevice != null));
        
        if (bluetoothAdapter != null) {
            android.util.Log.d(TAG, "bluetoothAdapter.isEnabled(): " + bluetoothAdapter.isEnabled());
        }
        
        if (bluetoothGatt != null) {
            android.util.Log.d(TAG, "bluetoothGatt.getServices().size(): " + bluetoothGatt.getServices().size());
        }
        
        android.util.Log.d(TAG, "=== 连接状态调试信息结束 ===");
    }
    
    /**
     * 保存最后连接的设备地址
     * @param address 设备地址
     */
    private void saveLastDeviceAddress(String address) {
        if (address == null || address.isEmpty()) {
            android.util.Log.w(TAG, "设备地址为空，跳过保存");
            return;
        }
        
        try {
            // 保存到BleManager自己的SharedPreferences
            if (prefs != null) {
                prefs.edit().putString(KEY_LAST_DEVICE_ADDRESS, address).apply();
                android.util.Log.d(TAG, "已保存设备地址到BleManager: " + address);
            }
            
            // 同时保存到DeviceFragment使用的SharedPreferences
            if (context != null) {
                SharedPreferences devicePrefs = context.getSharedPreferences("ble_history", Context.MODE_PRIVATE);
                SharedPreferences.Editor deviceEditor = devicePrefs.edit();
                
                // 保存单个设备地址
                deviceEditor.putString("last_device", address);
                
                // ⭐ 修复：同时保存到history_device_set，与clearLastDeviceAddress的清除逻辑保持一致
                Set<String> addrSet = devicePrefs.getStringSet("history_device_set", new HashSet<>());
                Set<String> newAddrSet = new HashSet<>(addrSet); // 创建新的Set避免并发修改
                
                // ⭐ 修复：检查设备是否已存在，如果存在就不添加
                if (newAddrSet.contains(address)) {
                    android.util.Log.d(TAG, "设备地址已存在于历史列表中，跳过添加: " + address);
                } else {
                    newAddrSet.add(address);
                    android.util.Log.d(TAG, "设备地址已添加到历史列表中: " + address);
                }
                
                deviceEditor.putStringSet("history_device_set", newAddrSet);
                deviceEditor.apply();
                android.util.Log.d(TAG, "已保存设备地址到DeviceFragment: " + address + "，历史设备总数: " + newAddrSet.size());
            }
        } catch (Exception e) {
            android.util.Log.e(TAG, "保存设备地址失败", e);
        }
    }
    
    /**
     * 获取最后连接的设备地址
     * @return 设备地址
     */
    private String getLastDeviceAddress() {
        try {
            // 优先从DeviceFragment的SharedPreferences获取
            if (context != null) {
                SharedPreferences devicePrefs = context.getSharedPreferences("ble_history", Context.MODE_PRIVATE);
                String address = devicePrefs.getString("last_device", null);
                if (address != null && !address.isEmpty()) {
                    return address;
                }
            }
            
            // 如果DeviceFragment中没有，从BleManager自己的SharedPreferences获取
            if (prefs != null) {
                return prefs.getString(KEY_LAST_DEVICE_ADDRESS, null);
            }
        } catch (Exception e) {
            android.util.Log.e(TAG, "获取设备地址失败", e);
        }
        return null;
    }
    
    /**
     * 清除指定的设备地址
     * @param deviceAddress 要清除的设备地址
     */
    public void clearSpecificDeviceAddress(String deviceAddress) {
        if (deviceAddress == null || deviceAddress.isEmpty()) {
            android.util.Log.w(TAG, "设备地址为空，跳过清除");
            return;
        }
        
        android.util.Log.d(TAG, "清除指定设备地址: " + deviceAddress);
        
        // 清除BleManager自己的SharedPreferences中的历史设备地址
        if (prefs != null) {
            SharedPreferences.Editor editor = prefs.edit();
            editor.remove(KEY_LAST_DEVICE_ADDRESS);
            editor.apply();
            android.util.Log.d(TAG, "已清除BleManager SharedPreferences中的历史设备地址");
        }
        
        // 同时清除DeviceFragment使用的SharedPreferences中的指定设备地址
        if (context != null) {
            SharedPreferences devicePrefs = context.getSharedPreferences("ble_history", Context.MODE_PRIVATE);
            SharedPreferences.Editor deviceEditor = devicePrefs.edit();
            
            // 清除单个设备地址
            deviceEditor.remove("last_device");
            
            // ⭐ 修复：从history_device_set中移除指定设备地址
            Set<String> addrSet = devicePrefs.getStringSet("history_device_set", new HashSet<>());
            Set<String> newAddrSet = new HashSet<>(addrSet); // 创建新的Set避免并发修改
            newAddrSet.remove(deviceAddress);
            deviceEditor.putStringSet("history_device_set", newAddrSet);
            
            deviceEditor.apply();
            android.util.Log.d(TAG, "已从history_device_set中移除设备地址: " + deviceAddress + "，剩余设备数: " + newAddrSet.size());
        }
        
        android.util.Log.d(TAG, "已清除指定设备地址");
    }
} 